package com.motu.monstercity.server.game.log;

import com.alibaba.fastjson.JSONObject;
import com.motu.data.UserLoginDevice;
import com.motu.monstercity.module.common.utility.Constant;
import com.motu.monstercity.module.common.utility.ServerParam;
import com.motu.monstercity.server.game.commondata.bag.ItemId;
import com.motu.monstercity.server.game.commondata.cave.CaveMain;
import com.motu.monstercity.server.game.commondata.partner.PartnerConstant;
import com.motu.monstercity.server.game.commondata.partner.PartnerMain;
import com.motu.monstercity.server.game.logic.PartnerManager;
import com.motu.monstercity.server.game.logic.RewardItem;
import com.motu.monstercity.server.game.userdata.*;
import com.motu.vertx.module.utility.logsdk.LogSDKManager;
import com.motu.vertx.module.utility.logsdk.ThinkingDataBaseManager;
import com.motu.vertx.module.utility.toolset.TimeUtils;
import com.motu.vertx.module.utility.toolset.Tool;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.auth.User;
import org.apache.kafka.common.protocol.types.Field.Str;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

/**
 * 数数SDK数据采集
 */
public class ThinkingDataManager extends ThinkingDataBaseManager {

	/**
	 * 注意事项：
	 * 不同事件的事件属性最好不要重名，因为一个属性只能有一个类型，如果有不同事件定义了相同属性名称，但是类型不同，那么属性类型会以第一个上报的为准，另外的事件上报可能就会失败
	 * 例如事件A定义type属性，是int类型（dataObj.put("type", type)） 事件B也定义type属性，是string类型（dataObj.put("type", String.valueOf(type))）
	 * 这种情况就是不允许的，如果都要用type属性，那么类型需要统一，最好是把type属性名称区分一下，例如a_type和b_type
	 */

	private static final Logger logger = LoggerFactory.getLogger(ThinkingDataManager.class);

	// 公共属性
	public static final String SERVER_ID = "server_id";//区服id
	public static final String PLATFORM = "platform";//平台id
	public static final String CHANNEL = "channel";//子渠道id
	public static final String USER_ACCOUNT_ID = "account_id";//用户账号ID
	public static final String OS_VERSION = "ryosversion";//操作系统版本
	public static final String OS = "ryos";//操作系统
	public static final String DEVICE_TYPE = "rydevicetype";//设备型号
	public static final String APP_VERSION = "app_version";//app版本
	public static final String PRODUCER = "producer";//手机生产商（例如Apple）
	public static final String NETWORK_TYPE = "network_type";//网络类型
	public static final String OPERATOR = "operator";//运营商
	public static final String DEVICE_ID_TD = "device_id_td";//数数sdk采集的设备id
	public static final String SIMULATOR = "simulator";//模拟器
	public static final String SERVER_ZONE = "server_zone";//服务器分区
	public static final String USER_CURRENT_LEVEL = "user_current_level";//当前等级
	public static final String USER_CURRENT_VIP = "user_current_vip";//当前vip等级
	public static final String USER_DIAMOND_HOLD = "user_diamond_hold";//当前持有钻石
	public static final String USER_GOLD_HOLD = "user_gold_hold";//当前持有金钱
	public static final String USER_CURRENT_VIPSCORE = "user_current_vipscore";//当前付费vip积分
	public static final String USER_CURRENT_VIPGIFTCORE = "user_current_vipgiftscore";//当前免费vip积分
	public static final String USER_CURRENT_STAGE_KEY = "user_current_stage_key";//当前副本章节组合key
	public static final String USER_MAX_POWER = "user_max_power"; // 用户历史最高战力
	public static final String USER_MAX_ANIMAL_WAVES = "user_animal_waves"; // 兽潮波数


	// 用户事件
	public static final String EVENT_REGISTER = "register";//用户注册
	public static final String EVENT_LOGIN = "login";//用户登录
	public static final String EVENT_LOGOUT = "logout";//用户登出
	public static final String EVENT_USER_ORDER = "user_order";//用户订单
	public static final String EVENT_ITEM_GET = "item_get";//道具获取
	public static final String EVENT_ITEM_COST = "item_cost";//道具消耗
	public static final String EVENT_LEVEL_UP = "level_up";//玩家等级升级
	public static final String EVENT_IMPORTANT_RESOURCES_GET = "important_resources_get";//干员/秘书/武器获得
	public static final String EVENT_PARTNER_LEVEL_UP = "partner_level_up";//玩家干员升级/升星
	public static final String EVENT_SHOP_BUY = "shop_buy";//主城商店购买
	public static final String EVENT_WEAPON_UPGRADES = "weapon_upgrades";//武器升级
	public static final String EVENT_TASK_FLOW = "task_flow";// 任务流水
	public static final String EVENT_STAGE_FIGHT = "stage_fight";//副本挑战事件
	public static final String EVENT_LOTTERY_LOG = "lottery_log";// 转盘抽奖
	public static final String EVENT_WEAPON_REFINEMENT = "weapon_refinement";// 武器洗练结果替换

	public static final String EVENT_CAVE_FIGHT = "cave_fight";// 地下洞窟战斗事件
	public static final String EVENT_WORLD_SKILL_LEVEL_UP = "world_skill_level_up";// 远征技能升级
	public static final String EVENT_PEASON_FULL = "peason_full";// 人口达到上限
	public static final String EVENT_UNION_DONATE = "union_donate";// 联盟捐赠
	public static final String EVENT_UNION_GIFT_BOX = "union_box_get_reward";// 1~6级联盟赠礼领取次数
	public static final String EVENT_UNION_HELP = "union_help";// 联盟互助
	public static final String EVENT_WORLD_ENERGY_BUY = "world_enegry_buy";// 远征体力购买监控（第6）
	public static final String EVENT_WORLD_MONSTER_LEVEL_UP = "world_monster_level_up";// 远征全胜怪兽等级提升时上报（每10级一次）（第3）


	//用户事件部分事件字段需要定义的类型
	public static final String EVENT_LEVEL_UP_LEVEL = "level";//玩家等级升级--等级
	public static final String EVENT_LEVEL_UP_VIP_LEVEL = "vip_level";//玩家等级升级--vip等级

	public static final String EVENT_PARTNER_LEVEL_UP_LEVEL = "level";//玩家干员升级/升星
	public static final String EVENT_PARTNER_LEVEL_UP_STAR = "star";//玩家干员升级/升星


	/**
	 * 设置公共的系统参数和事件参数
	 *
	 * @param eventName       事件名
	 * @param eventParams     事件参数
	 * @param userInfo        用户信息
	 * @return 系统参数对象
	 */
	protected static JSONObject getCommonParams(String eventName, JSONObject eventParams, UserInfo userInfo) {
		JSONObject systemParams = new JSONObject();

		// 系统参数
		systemParams.put(ACCOUNT_ID, String.valueOf(userInfo.getId()));//用户id
		if (!Tool.isEmpty(userInfo.getDistinctId())) {
			systemParams.put(DISTINCT_ID, userInfo.getDistinctId());//访客id
		}
		systemParams.put(EVENT_NAME, eventName);//事件名
		systemParams.put(DATA_TYPE, DataType.TRACK.getType());//事件类型
		systemParams.put(ZONE_OFFSET, userInfo.getTimezone());//客户端时区

		// 事件参数
		if (!Tool.isEmpty(userInfo.getTimezone())) {
			eventParams.put(ZONE_OFFSET, Float.parseFloat(userInfo.getTimezone()));//客户端时区
		}
		eventParams.put(USER_CURRENT_LEVEL, userInfo.getLevel());//等级
		eventParams.put(USER_CURRENT_VIP, userInfo.getVip());//vip等级
		eventParams.put(USER_CURRENT_VIPSCORE, userInfo.getVipScore());//当前vip付费积分
//		eventParams.put(USER_CURRENT_VIPGIFTCORE, 0);//当前免费vip积分
		eventParams.put(USER_DIAMOND_HOLD, userInfo.getDiamond());//当前持有钻石
		eventParams.put(USER_GOLD_HOLD, userInfo.getGold());//当前持有金钱
		eventParams.put(USER_CURRENT_STAGE_KEY, userInfo.getStageKey());//当前副本章节组合key
		eventParams.put(USER_MAX_POWER, userInfo.getMaxPower()); // 历史最高战力
		return systemParams;
	}

	/**
	 * 获取设备参数（登录/注册/付费等重要事件设置即可）
	 *
	 * @param systemParams    系统参数
	 * @param eventParams     事件参数
	 * @param userLoginDevice 用户登录设备信息
	 */
	protected static void getDeviceParams(JSONObject systemParams, JSONObject eventParams, UserLoginDevice userLoginDevice) {
		systemParams.put(IP, userLoginDevice.getIp());//ip
		eventParams.put(PLATFORM, userLoginDevice.getPlatform());//平台号
		eventParams.put(CHANNEL, userLoginDevice.getChannel());//渠道号
		eventParams.put(USER_ACCOUNT_ID, userLoginDevice.getAccountId());//用户账号ID
		eventParams.put(SERVER_ID, String.valueOf(userLoginDevice.getServerId()));//服务器id
		eventParams.put(OS_VERSION, userLoginDevice.getRyosVersion());//操作系统版本
		eventParams.put(OS, userLoginDevice.getRyos());//操作系统
		eventParams.put(DEVICE_TYPE, userLoginDevice.getDeviceType());//设备型号
		eventParams.put(APP_VERSION, userLoginDevice.getAppVersion());//app版本
		eventParams.put(PRODUCER, userLoginDevice.getProducer());//手机生产商（例如Apple）
		eventParams.put(NETWORK_TYPE, userLoginDevice.getNetworkType());//网络类型
		eventParams.put(OPERATOR, userLoginDevice.getOperator());//运营商
		eventParams.put(DEVICE_ID_TD, userLoginDevice.getTdDeviceId());//数数sdk采集的设备id
		eventParams.put(SIMULATOR, userLoginDevice.getSimulator());//模拟器
		if (!Tool.isEmpty(ServerParam.SERVER_ZONE)) {
			eventParams.put(SERVER_ZONE, ServerParam.SERVER_ZONE);//服务器分区
		}
	}

	/*****************  用户数据 *******************/
	/**
	 * 用户注册数据（注册数据和注册事件必须是服务端发送的第一个事件）
	 *
	 * @param userInfo        用户信息
	 * @param userLoginDevice 用户登录设备信息
	 * @param registerTime    注册时间
	 * @param firstLoginTime  首次登录时间
	 * @param isOldUser       是否滚服用户
	 * @param nickname        用户名称
	 */
	public static void pushUserRegisterData(UserInfo userInfo, UserLoginDevice userLoginDevice, long registerTime, long firstLoginTime, String isOldUser, String nickname) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userInfo.getId()));
		if (!Tool.isEmpty(userLoginDevice.getDistinctId())) {
			params.put(DISTINCT_ID, userLoginDevice.getDistinctId());
		}
		params.put(DATA_TYPE, DataType.USER_SET_ONCE.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("account_id", userLoginDevice.getAccountId());//账户id
		userParams.put("device_id", userLoginDevice.getDeviceId());//设备id
		userParams.put(SERVER_ID, userLoginDevice.getServerId());//区服id
		userParams.put(PLATFORM, userLoginDevice.getPlatform());//平台id
		userParams.put(CHANNEL, userLoginDevice.getChannel());//注册渠道
		userParams.put("register_time", TimeUtils.getTimeFullStr(registerTime));//注册时间
		userParams.put("first_login_time", TimeUtils.getTimeFullStr(firstLoginTime));//首次登录时间
		if (!isOldUser.isEmpty()) {
			userParams.put("is_old_user", true);//是否滚服用户
			userParams.put("device_first_time", TimeUtils.getTimeFullStr(Integer.parseInt(isOldUser)));//首次设备创建时间
		} else {
			userParams.put("is_old_user", false);//是否滚服用户
			userParams.put("device_first_time", TimeUtils.getTimeFullStr(TimeUtils.getCurTime()));//首次设备创建时间
		}
		userParams.put("nickname", nickname);//用户名称
		if (!Tool.isEmpty(ServerParam.SERVER_ZONE)) {
			userParams.put(SERVER_ZONE, ServerParam.SERVER_ZONE);//服务器分区
		}

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户首次充值时间数据
	 *
	 * @param userId       用户id
	 * @param distinctId   访客id
	 * @param firstPayTime 首次充值时间
	 */
	public static void pushFirstPayTimeData(long userId, String distinctId, long firstPayTime) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		if (!distinctId.isEmpty()) {
			params.put(DISTINCT_ID, distinctId);
		}
		params.put(DATA_TYPE, DataType.USER_SET_ONCE.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("first_pay_time", TimeUtils.getTimeFullStr(firstPayTime));//首次充值时间

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户登录累加登录次数数据
	 *
	 * @param userId 用户id
	 */
	public static void pushUserLoginData(long userId) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		params.put(DATA_TYPE, DataType.USER_ADD.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("total_login_count", 1);//累加登录次数

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户累计付费金额数据
	 *
	 * @param userId       用户id
	 * @param totalRevenue 累加付费金额
	 */
	public static void pushUserIapBuyData(long userId, double totalRevenue) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		params.put(DATA_TYPE, DataType.USER_ADD.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("total_revenue", totalRevenue);//累加付费金额

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 登出时累加游戏时长
	 *
	 * @param userId             用户id
	 * @param currentSessionTime 累加游戏时长
	 */
	public static void pushLogoutSessionTime(long userId, long currentSessionTime) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		params.put(DATA_TYPE, DataType.USER_ADD.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("current_session_time", currentSessionTime);//累加游戏时长

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户登出数据
	 *
	 * @param userInfo        用户信息
	 * @param userLoginDevice 用户登录设备信息
	 * @param loginDays       累计登录天数
	 */
	public static void pushUserLogoutData(UserInfo userInfo, UserLoginDevice userLoginDevice, int loginDays,int nextMonsterTideId) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userInfo.getId()));
		if (!Tool.isEmpty(userLoginDevice.getDistinctId())) {
			params.put(DISTINCT_ID, userLoginDevice.getDistinctId());
		}
		params.put(DATA_TYPE, DataType.USER_SET.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("last_login_time", TimeUtils.getTimeFullStr(TimeUtils.getCurTime()));//最后登录时间
		userParams.put(USER_DIAMOND_HOLD, userInfo.getDiamond());//当前持有钻石
		userParams.put(USER_GOLD_HOLD, userInfo.getGold());// 当前持有金钱
		userParams.put(USER_CURRENT_LEVEL, userInfo.getLevel());// 玩家等级
		userParams.put(USER_CURRENT_VIP, userInfo.getVip());// 当前VIP等级
		userParams.put(USER_CURRENT_VIPSCORE, userInfo.getVipScore());// 当前付费vip积分
//		userParams.put(USER_CURRENT_VIPGIFTCORE, 0);// 当前免费vip积分
		userParams.put(USER_CURRENT_STAGE_KEY, userInfo.getStageKey());// 当前关卡章节
		userParams.put(USER_MAX_POWER, userInfo.getMaxPower());// 历史最高战力
		userParams.put("login_days", loginDays);// 累计登录天数
		userParams.put(USER_MAX_ANIMAL_WAVES, nextMonsterTideId);// 兽潮波数


		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户最后充值时间数据
	 *
	 * @param userId      用户id
	 * @param distinctId  访客id
	 * @param lastPayTime 最后充值时间
	 */
	public static void  pushLastPayTimeData(long userId, String distinctId, long lastPayTime) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		if (!distinctId.isEmpty()) {
			params.put(DISTINCT_ID, distinctId);
		}
		params.put(DATA_TYPE, DataType.USER_SET.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("last_pay_time", TimeUtils.getTimeFullStr(lastPayTime));//最后充值时间

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户改名
	 *
	 * @param userId     用户id
	 * @param distinctId 访客id
	 * @param nickname   用户名称
	 */
	public static void pushUserChangeNameData(long userId, String distinctId, String nickname) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		if (!distinctId.isEmpty()) {
			params.put(DISTINCT_ID, distinctId);
		}
		params.put(DATA_TYPE, DataType.USER_SET.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("nickname", nickname);//用户名称

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户登录累加回归次数数据
	 *
	 * @param userId 用户id
	 */
	public static void pushUserReBackData(long userId) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		params.put(DATA_TYPE, DataType.USER_ADD.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("reback", 1);//累加回归次数

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户登录累加回归登录天数数据
	 *
	 * @param userId 用户id
	 */
	public static void pushUserReBackLoginDaysData(long userId) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		params.put(DATA_TYPE, DataType.USER_ADD.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("reback_login_days", 1);//累加回归登录天数

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户封禁数据
	 *
	 * @param userId     用户id
	 * @param distinctId 访客id
	 * @param type       操作类型 1为封禁，2为解封
	 */
	public static void pushUserBanData(long userId, String distinctId, int type) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		if (!distinctId.isEmpty()) {
			params.put(DISTINCT_ID, distinctId);
		}
		params.put(DATA_TYPE, DataType.USER_SET.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("gm_action_type", type); // 操作类型 1为封禁，2为解封
		userParams.put("gm_action_time", TimeUtils.getTimeFullStr(TimeUtils.getCurTime())); // 操作时间

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}

	/**
	 * 用户语言设置
	 *
	 * @param userId     用户id
	 * @param distinctId 访客id
	 * @param language   用户设置语言类型
	 */
	public static void pushUserLanguageData(long userId, String distinctId, int language) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject params = new JSONObject();
		params.put(ACCOUNT_ID, String.valueOf(userId));
		if (!distinctId.isEmpty()) {
			params.put(DISTINCT_ID, distinctId);
		}
		params.put(DATA_TYPE, DataType.USER_SET.getType());

		// 用户属性
		JSONObject userParams = new JSONObject();
		userParams.put("user_language", language);//用户语言

		params.put(DATA, userParams);
		LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
	}


	/*****************  事件数据 *******************/

	/**
	 * 用户注册事件（注册数据和注册事件必须是服务端发送的第一个事件）
	 *
	 * @param userInfo        用户信息
	 * @param userLoginDevice 用户登录设备信息
	 * @param isOldUser       是否滚服用户
	 */
	public static void pushRegisterEvent(UserInfo userInfo, UserLoginDevice userLoginDevice, String isOldUser) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_REGISTER, eventParams, userInfo);

			// 设备参数
			getDeviceParams(params, eventParams, userLoginDevice);

			// 设置事件参数
			if (!isOldUser.isEmpty()) {
				eventParams.put("is_old_user", true);//是否滚服用户
				eventParams.put("device_first_time", TimeUtils.getTimeFullStr(Long.parseLong(isOldUser)));//首次设备创建时间
			} else {
				eventParams.put("is_old_user", false);//是否滚服用户
				eventParams.put("device_first_time", TimeUtils.getTimeFullStr(TimeUtils.getCurTime()));//首次设备创建时间
			}

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	/**
	 * 用户登录事件
	 *
	 * @param userInfo        用户信息
	 * @param userLoginDevice 用户登录设备信息
	 * @param firstLogin      是否首次登录
	 */
	public static void pushLoginEvent(UserInfo userInfo, UserLoginDevice userLoginDevice, boolean firstLogin) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_LOGIN, eventParams, userInfo);

			// 设备参数
			getDeviceParams(params, eventParams, userLoginDevice);

			// 设置事件参数
			eventParams.put("first_login", firstLogin);//是否首次登录

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	/**
	 * 用户登出事件
	 *
	 * @param userInfo        用户信息
	 * @param onlineTime      在线时长
	 * @param loginDays       累计登录天数
	 */
	public static void pushLogoutEvent(UserInfo userInfo, long onlineTime, int loginDays, UserThinkingData userThinkingData,int nextMonsterTideId) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_LOGOUT, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("online_time", onlineTime);//在线时长
			eventParams.put("login_days", loginDays);//累计登录天数

			eventParams.put("coin_get", userThinkingData.getCoinGet());//本次登录期间金币获得数量
			eventParams.put("coin_cost", userThinkingData.getCoinCost());//本次登录期间金币消耗数量
			eventParams.put("user_animal_waves", nextMonsterTideId);//兽潮当前波数


			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	/**
	 * 充值-用户订单事件
	 *
	 * @param userInfo        用户信息
	 * @param userLoginDevice 用户登录设备信息
	 * @param orderId         订单id
	 * @param payAmount       支付金额
	 * @param goodsId         商品id
	 * @param firstPay        是否首充
	 * @param iapGiftId       礼包的id
	 * @param type            礼包类型
	 * @param payType         支付类型（例如苹果支付、谷歌支付等）
	 * @param itemType        付费道具类型（1付费代金券 2免费代金券 3付费代币 4免费代币 5魔兔币）
	 * @param actId           活动ID
	 * @param chargeType      充值分类
	 */
	public static void pushUserOrderEvent(UserInfo userInfo, UserLoginDevice userLoginDevice, String orderId, double payAmount, int goodsId,
										  boolean firstPay, int iapGiftId, int type, String payType, int itemType, long actId, int chargeType) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_USER_ORDER, eventParams, userInfo);

			// 设备参数
			getDeviceParams(params, eventParams, userLoginDevice);

			// 设置事件参数
			eventParams.put("order_id", orderId);//订单id
			eventParams.put("pay_amount", payAmount);//支付金额
			eventParams.put("goods_id", String.valueOf(goodsId));//商品id
			eventParams.put("first_pay", firstPay);//是否首充
			eventParams.put("iap_gift_id", String.valueOf(iapGiftId));//礼包的id
			eventParams.put("type", String.valueOf(type));//礼包类型
			eventParams.put("pay_type", payType);//支付类型
			eventParams.put("item_type", itemType);//付费道具类型（1付费代金券 2免费代金券 3付费代币 4免费代币 5魔兔币）
			eventParams.put("activity_id", actId); // 活动id
			eventParams.put("charge_type", chargeType); // 系统分类

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	/**
	 * 物品消耗获得事件
	 *
	 * @param userInfo        用户信息
	 * @param eventName       事件名
	 * @param itemId          道具id
	 * @param logType         日志类型
	 * @param amountBefore    变化前数量
	 * @param amount          变化数值
	 * @param amountAfter     变化后数量
	 * @param extParam        附加参数
	 */
	public static void pushItemEvent(UserInfo userInfo, String eventName, int itemId, int logType,
									 long amountBefore, long amount, long amountAfter, String extParam) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(eventName, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("item_id", itemId);//道具ID
			eventParams.put("log_type", logType);//日志类型
			eventParams.put("amount_before", amountBefore);//变化前数量
			eventParams.put("amount", amount);//变化数值
			eventParams.put("amount_after", amountAfter);//变化后数量
			eventParams.put("ext_param", extParam);//附加参数

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	/**
	 * 用户等级升级事件
	 * @param userInfo			 用户信息
	 * @param level_type		 等级类型 ( level:等级,vip_level:ip等级）
	 * @param before_level		 升级前等级
	 * @param after_level		 升级后等级
	 */
	public static void pushUserLevelUpEvent(UserInfo userInfo, String level_type, int before_level, int after_level) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_LEVEL_UP, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("level_type", level_type);//等级类型 ( level:等级,vip_level:ip等级）)
			eventParams.put("before_level", before_level);//升级前等级
			eventParams.put("after_level", after_level);//升级后等级

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	/**
	 * 地下洞窟战斗事件
	 */
	public static void pushUserCaveEvent(UserInfo userInfo, CaveMain caveMain) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_CAVE_FIGHT, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("cave_main_id", caveMain.getId());//
			eventParams.put("area_type", caveMain.getAreaType());//
			eventParams.put("floor_id", caveMain.getFloorId());//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	/**
	 * 远征技能升级事件
	 * @param userInfo
	 * @param sortId  第几个技能，1，2，3，4
	 * @param newLevel 升级后的等级
	 */
	public static void pushUserWorldSkillLevelUpEvent(UserInfo userInfo, int sortId, int newLevel) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_WORLD_SKILL_LEVEL_UP, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("sort_id", sortId);//
			eventParams.put("after_level", newLevel);//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	/**
	 * 人口达到总容量时上报当前居民数
	 * @param userInfo
	 * @param peasonNum  当前人口总量
	 * @param houseNum 当前居民数量
	 */
	public static void pushUserPeasonFullEvent(UserInfo userInfo, int peasonNum, int houseNum) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_PEASON_FULL, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("peason_num", peasonNum);//
			eventParams.put("house_num", houseNum);//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 联盟捐赠
	public static void pushUserUnionDonateEvent(UserInfo userInfo, int type) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_UNION_DONATE, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("donate_type", type);//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}


	// 5、联盟互助帮助他人次数（第7）
	public static void pushUserUnionHelpEvent(UserInfo userInfo, int helpNum) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_UNION_HELP, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("help_num", helpNum);//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 1~6级联盟赠礼领取次数
	public static void pushUserUnionGiftBoxRewardEvent(UserInfo userInfo, int type) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_UNION_GIFT_BOX, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("type", type);//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 远征全胜怪兽等级提升时上报（每10级一次）（第3）
	public static void pushUserWorldMonsterLeveUpEvent(UserInfo userInfo, int curLevel) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_WORLD_MONSTER_LEVEL_UP, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("after_level", curLevel);//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 远征体力购买监控（第6）
	public static void pushUserWorldEnergyBuyEvent(UserInfo userInfo, int curNum) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_WORLD_ENERGY_BUY, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("buy_num", curNum);//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}


	/**
	 * 用户干员升级/升星事件
	 * @param userInfo			 用户信息
	 * @param type		 类型 ( level:等级,star:星级）
	 * @param before_level		 升级前等级/星级
	 * @param after_level		 升级后等级/星级
	 */
	public static void pushUserPartnerLevelUpEvent(UserInfo userInfo, String type, int before_level, int after_level, UserPartner userPartner, List<RewardItem> costItems, boolean isTen) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_PARTNER_LEVEL_UP, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("up_type", type);//类型 ( level:等级,star:星级）
			eventParams.put("before_level", before_level);//升级前等级
			eventParams.put("after_level", after_level);//升级后等级
			eventParams.put("is_ten", isTen ? 1 : 0);//

			JSONObject partnerInfo = new JSONObject();
			partnerInfo.put("talent", userPartner.takeTotalTalent());
			partnerInfo.put("power", userPartner.getTotalPower());
			partnerInfo.put("character", getCharacterName(userPartner.getCharacterType()));
			//List<JSONObject> list = new ArrayList<>();
			//list.add(partnerInfo);
			eventParams.put("partner_info", partnerInfo);// 属性信息

			eventParams.put("cost", getRewardItemList(costItems));// 消耗内容

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 主城商店购买
	public static void pushUserShopBuyEvent(UserInfo userInfo, int itemId, long itemNum, int itemIdCost, long itemNumCost, int shopType) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_SHOP_BUY, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("item_cost_id", itemIdCost);// 消耗道具id
			eventParams.put("item_cost_num", itemNumCost);//消耗道具数量
			eventParams.put("purcharse_goods_id", itemId);// 获得的道具id
			eventParams.put("purcharse_goods_num", itemNum);//获得
			eventParams.put("shop_type", shopType);//商店类型

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 副本挑战事件
	public static void pushUserStageFightEvent(UserInfo userInfo, int type, int stageId, boolean isSucc, UserPower userPower) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_STAGE_FIGHT, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("power", userPower.getPower());// 当前战力，有各种加成如称号
			eventParams.put("result", isSucc);//
			eventParams.put("stage_id", stageId);//
			eventParams.put("stage_type", type);// 1--主线关卡  2--怪兽挑战

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 转盘抽奖事件
	public static void pushUserDrawEvent(UserInfo userInfo, boolean isTen, int itemId, List<RewardItem> rewardItemList) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_LOTTERY_LOG, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("lottery_type", isTen ? 10 : 1);// 抽奖类型1-单抽,10-10连抽
			int costType = 0;// 0--免费  1--游戏币  2--钻石
			if (itemId == ItemId.DIAMOND) {
				costType = 2;
			} else if (itemId == ItemId.TIGER_DRAW_ITEM) {
				costType = 1;
			}
			eventParams.put("cost_type", costType);//
			eventParams.put("get_items", getRewardItemList(rewardItemList));//

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 武器升级
	public static void pushUserWeaponLevelUpEvent(UserInfo userInfo, long dbid, int weaponId, int curLevel, int newLevel, int num) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_WEAPON_UPGRADES, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("weapon_id", weaponId);// 武器id
			eventParams.put("weapon_dbid", dbid);// 武器id
			eventParams.put("weapon_after_level", newLevel);//升级后武器等级
			eventParams.put("weapon_before_level", curLevel);// 升级前的等级
			eventParams.put("weapon_level_type", num);//升级次数

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// 武器洗练结果替换
	public static void pushUserWeaponRefreshEvent(UserInfo userInfo, long dbid, int weaponId, int refreshType, JsonArray attAdd, JsonArray attAdd2) {
		// ThinkingDataSDK，用的是alibaba.fastjson
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_WEAPON_REFINEMENT, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("weapon_id", weaponId);// 武器id
			eventParams.put("weapon_dbid", dbid);// dbid
			eventParams.put("weapon_reforge_type", refreshType);//1--普通洗练  2--高级洗练  3--一键洗练
			eventParams.put("weapon_before_reforge", getWeaponAdd(attAdd));// 记录当前武器属性，格式：[{"属性名":自由,"加成":7},{"属性名":博学,"加成":22},{},{},{}]
			eventParams.put("weapon_after_reforge", getWeaponAdd(attAdd2));//格式：[{"属性名":自由,"加成":7},{"属性名":博学,"加成":22},{},{},{}]

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

	// List<RewardItem> 转成JSONObject 数组
	private static List<JSONObject> getRewardItemList(List<RewardItem> rewardItemList) {
		List<JSONObject> result = new ArrayList<>();
		for (RewardItem rewardItem : rewardItemList) {
			JSONObject jsonObject = new JSONObject();
			jsonObject.put("itemId", rewardItem.getItemId());
			jsonObject.put("itemNum", rewardItem.getItemNum());
			result.add(jsonObject);
		}
		return result;
	}

	// 武器属性加成 jsonArray转成JSONObject 数组
	private static List<JSONObject> getWeaponAdd(JsonArray jsonArray) {
		List<JSONObject> result = new ArrayList<>();
		for (int i=0;i<jsonArray.size();i++) {// ["3_10","1_8","4_4","5_6","5_13"]
			String str = jsonArray.getString(i);
			String[] arr = str.split("_");
			int charType = Integer.parseInt(arr[0]);// 性格类型
			int addValue = Integer.parseInt(arr[1]);// 加成值
 			JSONObject jsonObject = new JSONObject();
			jsonObject.put("name", getCharacterName(charType));
			jsonObject.put("addValue", addValue);
			result.add(jsonObject);
		}
		return result;
	}

	// 获取干员的性格名称
	private static String getCharacterName(int charType) {
		String name = "博学";
		if (charType == Constant.CHARACTER_TYPE_1) {
			name = "博学";
		} else if (charType == Constant.CHARACTER_TYPE_2) {
			name = "勇猛";
		} else if (charType == Constant.CHARACTER_TYPE_3) {
			name = "自由";
		} else if (charType == Constant.CHARACTER_TYPE_4) {
			name = "艺术";
		} else if (charType == Constant.CHARACTER_TYPE_5) {
			name = "勤劳";
		}
		return name;
	}

	/**
	 * 任务流水
	 * @param userInfo
	 * @param taskType 类型（1--每日任务 2--主线任务 3--成就 4--支线任务 5--七日重建）等等
	 * @param taskId 任务ID
	 * @param taskState 0--前往 1--接取 2--完成（跟策划确认只传2就行）
	 */
	public static void pushTaskFlowEvent(UserInfo userInfo, int taskType, long taskId, int taskState) {
		JSONObject eventParams = new JSONObject();// 事件参数
		try {
			// 设置公共的系统参数和事件参数
			JSONObject params = getCommonParams(EVENT_TASK_FLOW, eventParams, userInfo);

			// 设置事件参数
			eventParams.put("task_type", taskType);
			eventParams.put("task_id",taskId);
			eventParams.put("task_state", taskState);

			params.put(DATA, eventParams);
			LogSDKManager.sendThinkingData(LogSDKManager.KAFKA_TOPIC_THINKINGDATA, params);
		} catch (Exception e) {
			logger.error(Tool.getException(e));
		}
	}

}
